/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using AvgWindow11Stride4Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Average, pooling::Forward>;
TYPED_TEST_SUITE(AvgWindow11Stride4Forward, GTestTypePairs);
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {49.,  51.,  55.,  57.,  79.,  81.,
                                         85.,  87.,  139., 141., 145., 147.,
                                         169., 171., 175., 177.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {81., 85., 141., 145.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  98.,  101., 102., 109., 110., 113., 114., 157., 158., 161.,
      162., 169., 170., 173., 174., 277., 278., 281., 282., 289., 290.,
      293., 294., 337., 338., 341., 342., 349., 350., 353., 354.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 162., 169., 170.,
                                         281., 282., 289., 290.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193., 194., 195., 196., 201., 202., 203., 204., 217., 218., 219.,
      220., 225., 226., 227., 228., 313., 314., 315., 316., 321., 322.,
      323., 324., 337., 338., 339., 340., 345., 346., 347., 348., 553.,
      554., 555., 556., 561., 562., 563., 564., 577., 578., 579., 580.,
      585., 586., 587., 588., 673., 674., 675., 676., 681., 682., 683.,
      684., 697., 698., 699., 700., 705., 706., 707., 708.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {321., 322., 323., 324., 337., 338.,
                                         339., 340., 561., 562., 563., 564.,
                                         577., 578., 579., 580.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {52.5,  55.,  59.,   61.,  84.5, 87.,
                                         91.,   93.,  148.5, 151., 155., 157.,
                                         180.5, 183., 187.,  189.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {86., 90., 150., 154.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      104., 105., 109., 110., 117., 118., 121., 122., 168., 169., 173.,
      174., 181., 182., 185., 186., 296., 297., 301., 302., 309., 310.,
      313., 314., 360., 361., 365., 366., 373., 374., 377., 378.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 172., 179., 180.,
                                         299., 300., 307., 308.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      207., 208., 209., 210., 217., 218., 219., 220., 233., 234., 235.,
      236., 241., 242., 243., 244., 335., 336., 337., 338., 345., 346.,
      347., 348., 361., 362., 363., 364., 369., 370., 371., 372., 591.,
      592., 593., 594., 601., 602., 603., 604., 617., 618., 619., 620.,
      625., 626., 627., 628., 719., 720., 721., 722., 729., 730., 731.,
      732., 745., 746., 747., 748., 753., 754., 755., 756.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {341., 342., 343., 344., 357., 358.,
                                         359., 360., 597., 598., 599., 600.,
                                         613., 614., 615., 616.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58.,  60.,  64.,  67.5,  69.5,  94.,  96.,  100., 103.5, 105.5,
      166., 168., 172., 175.5, 177.5, 202., 204., 208., 211.5, 213.5};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {96., 100., 168., 172.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115., 116., 119., 120., 127., 128., 134., 135., 138., 139.,
      187., 188., 191., 192., 199., 200., 206., 207., 210., 211.,
      331., 332., 335., 336., 343., 344., 350., 351., 354., 355.,
      403., 404., 407., 408., 415., 416., 422., 423., 426., 427.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 192., 199., 200.,
                                         335., 336., 343., 344.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x15x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      229., 230., 231., 232., 237., 238., 239., 240., 253., 254., 255., 256.,
      267., 268., 269., 270., 275., 276., 277., 278., 373., 374., 375., 376.,
      381., 382., 383., 384., 397., 398., 399., 400., 411., 412., 413., 414.,
      419., 420., 421., 422., 661., 662., 663., 664., 669., 670., 671., 672.,
      685., 686., 687., 688., 699., 700., 701., 702., 707., 708., 709., 710.,
      805., 806., 807., 808., 813., 814., 815., 816., 829., 830., 831., 832.,
      843., 844., 845., 846., 851., 852., 853., 854.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x15x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381., 382., 383., 384., 397., 398.,
                                         399., 400., 669., 670., 671., 672.,
                                         685., 686., 687., 688.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {56.5, 58.5, 62.5, 64.5, 94.,  96.,
                                         100., 102., 154., 156., 160., 162.,
                                         184., 186., 190., 192.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {81., 85., 141., 145.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      112., 113., 116., 117., 124., 125., 128., 129., 187., 188., 191.,
      192., 199., 200., 203., 204., 307., 308., 311., 312., 319., 320.,
      323., 324., 367., 368., 371., 372., 379., 380., 383., 384.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 162., 169., 170.,
                                         281., 282., 289., 290.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223., 224., 225., 226., 231., 232., 233., 234., 247., 248., 249.,
      250., 255., 256., 257., 258., 373., 374., 375., 376., 381., 382.,
      383., 384., 397., 398., 399., 400., 405., 406., 407., 408., 613.,
      614., 615., 616., 621., 622., 623., 624., 637., 638., 639., 640.,
      645., 646., 647., 648., 733., 734., 735., 736., 741., 742., 743.,
      744., 757., 758., 759., 760., 765., 766., 767., 768.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {321., 322., 323., 324., 337., 338.,
                                         339., 340., 561., 562., 563., 564.,
                                         577., 578., 579., 580.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60.5,  63.,  67.,   69.,  100.5, 103.,
                                         107.,  109., 164.5, 167., 171.,  173.,
                                         196.5, 199., 203.,  205.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {86., 90., 150., 154.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120., 121., 125., 126., 133., 134., 137., 138., 200., 201., 205.,
      206., 213., 214., 217., 218., 328., 329., 333., 334., 341., 342.,
      345., 346., 392., 393., 397., 398., 405., 406., 409., 410.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 172., 179., 180.,
                                         299., 300., 307., 308.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      239., 240., 241., 242., 249., 250., 251., 252., 265., 266., 267.,
      268., 273., 274., 275., 276., 399., 400., 401., 402., 409., 410.,
      411., 412., 425., 426., 427., 428., 433., 434., 435., 436., 655.,
      656., 657., 658., 665., 666., 667., 668., 681., 682., 683., 684.,
      689., 690., 691., 692., 783., 784., 785., 786., 793., 794., 795.,
      796., 809., 810., 811., 812., 817., 818., 819., 820.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {341., 342., 343., 344., 357., 358.,
                                         359., 360., 597., 598., 599., 600.,
                                         613., 614., 615., 616.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  69.,  73.,  76.5,  78.5,  112., 114., 118., 121.5, 123.5,
      184., 186., 190., 193.5, 195.5, 220., 222., 226., 229.5, 231.5};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {96., 100., 168., 172.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 137., 138., 145., 146., 152., 153., 156., 157.,
      223., 224., 227., 228., 235., 236., 242., 243., 246., 247.,
      367., 368., 371., 372., 379., 380., 386., 387., 390., 391.,
      439., 440., 443., 444., 451., 452., 458., 459., 462., 463.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 192., 199., 200.,
                                         335., 336., 343., 344.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x16x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265., 266., 267., 268., 273., 274., 275., 276., 289., 290., 291., 292.,
      303., 304., 305., 306., 311., 312., 313., 314., 445., 446., 447., 448.,
      453., 454., 455., 456., 469., 470., 471., 472., 483., 484., 485., 486.,
      491., 492., 493., 494., 733., 734., 735., 736., 741., 742., 743., 744.,
      757., 758., 759., 760., 771., 772., 773., 774., 779., 780., 781., 782.,
      877., 878., 879., 880., 885., 886., 887., 888., 901., 902., 903., 904.,
      915., 916., 917., 918., 923., 924., 925., 926.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x16x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381., 382., 383., 384., 397., 398.,
                                         399., 400., 669., 670., 671., 672.,
                                         685., 686., 687., 688.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  51.,  55.,   57.,   79.,   81.,   85.,   87.,   139.,  141.,
      145., 147., 191.5, 193.5, 197.5, 199.5, 221.5, 223.5, 227.5, 229.5};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {81., 85., 141., 145.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  98.,  101., 102., 109., 110., 113., 114., 157., 158.,
      161., 162., 169., 170., 173., 174., 277., 278., 281., 282.,
      289., 290., 293., 294., 382., 383., 386., 387., 394., 395.,
      398., 399., 442., 443., 446., 447., 454., 455., 458., 459.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 162., 169., 170.,
                                         281., 282., 289., 290.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193., 194., 195., 196., 201., 202., 203., 204., 217., 218., 219., 220.,
      225., 226., 227., 228., 313., 314., 315., 316., 321., 322., 323., 324.,
      337., 338., 339., 340., 345., 346., 347., 348., 553., 554., 555., 556.,
      561., 562., 563., 564., 577., 578., 579., 580., 585., 586., 587., 588.,
      763., 764., 765., 766., 771., 772., 773., 774., 787., 788., 789., 790.,
      795., 796., 797., 798., 883., 884., 885., 886., 891., 892., 893., 894.,
      907., 908., 909., 910., 915., 916., 917., 918.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {321., 322., 323., 324., 337., 338.,
                                         339., 340., 561., 562., 563., 564.,
                                         577., 578., 579., 580.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.5, 55.,  59.,   61.,  84.5, 87.,  91.,   93.,  148.5, 151.,
      155., 157., 204.5, 207., 211., 213., 236.5, 239., 243.,  245.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {86., 90., 150., 154.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      104., 105., 109., 110., 117., 118., 121., 122., 168., 169.,
      173., 174., 181., 182., 185., 186., 296., 297., 301., 302.,
      309., 310., 313., 314., 408., 409., 413., 414., 421., 422.,
      425., 426., 472., 473., 477., 478., 485., 486., 489., 490.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {171., 172., 179., 180.,
                                         299., 300., 307., 308.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      207., 208., 209., 210., 217., 218., 219., 220., 233., 234., 235., 236.,
      241., 242., 243., 244., 335., 336., 337., 338., 345., 346., 347., 348.,
      361., 362., 363., 364., 369., 370., 371., 372., 591., 592., 593., 594.,
      601., 602., 603., 604., 617., 618., 619., 620., 625., 626., 627., 628.,
      815., 816., 817., 818., 825., 826., 827., 828., 841., 842., 843., 844.,
      849., 850., 851., 852., 943., 944., 945., 946., 953., 954., 955., 956.,
      969., 970., 971., 972., 977., 978., 979., 980.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {341., 342., 343., 344., 357., 358.,
                                         359., 360., 597., 598., 599., 600.,
                                         613., 614., 615., 616.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58.,   60.,   64.,  67.5, 69.5,  94.,   96.,  100., 103.5,
      105.5, 166.,  168., 172., 175.5, 177.5, 229., 231., 235.,
      238.5, 240.5, 265., 267., 271.,  274.5, 276.5};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {96., 100., 168., 172.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115., 116., 119., 120., 127., 128., 134., 135., 138., 139.,
      187., 188., 191., 192., 199., 200., 206., 207., 210., 211.,
      331., 332., 335., 336., 343., 344., 350., 351., 354., 355.,
      457., 458., 461., 462., 469., 470., 476., 477., 480., 481.,
      529., 530., 533., 534., 541., 542., 548., 549., 552., 553.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {191., 192., 199., 200.,
                                         335., 336., 343., 344.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME1x18x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      229.,  230.,  231.,  232.,  237.,  238.,  239.,  240.,  253.,  254.,
      255.,  256.,  267.,  268.,  269.,  270.,  275.,  276.,  277.,  278.,
      373.,  374.,  375.,  376.,  381.,  382.,  383.,  384.,  397.,  398.,
      399.,  400.,  411.,  412.,  413.,  414.,  419.,  420.,  421.,  422.,
      661.,  662.,  663.,  664.,  669.,  670.,  671.,  672.,  685.,  686.,
      687.,  688.,  699.,  700.,  701.,  702.,  707.,  708.,  709.,  710.,
      913.,  914.,  915.,  916.,  921.,  922.,  923.,  924.,  937.,  938.,
      939.,  940.,  951.,  952.,  953.,  954.,  959.,  960.,  961.,  962.,
      1057., 1058., 1059., 1060., 1065., 1066., 1067., 1068., 1081., 1082.,
      1083., 1084., 1095., 1096., 1097., 1098., 1103., 1104., 1105., 1106.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID1x18x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381., 382., 383., 384., 397., 398.,
                                         399., 400., 669., 670., 671., 672.,
                                         685., 686., 687., 688.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  51.,  55.,  57.,  79.,  81.,  85.,  87.,  139., 141., 145., 147.,
      169., 171., 175., 177., 274., 276., 280., 282., 304., 306., 310., 312.,
      364., 366., 370., 372., 394., 396., 400., 402., 499., 501., 505., 507.,
      529., 531., 535., 537., 589., 591., 595., 597., 619., 621., 625., 627.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {81.,  85.,  141., 145., 306., 310.,
                                         366., 370., 531., 535., 591., 595.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,   98.,   101.,  102.,  109.,  110.,  113.,  114.,  157.,  158.,
      161.,  162.,  169.,  170.,  173.,  174.,  277.,  278.,  281.,  282.,
      289.,  290.,  293.,  294.,  337.,  338.,  341.,  342.,  349.,  350.,
      353.,  354.,  547.,  548.,  551.,  552.,  559.,  560.,  563.,  564.,
      607.,  608.,  611.,  612.,  619.,  620.,  623.,  624.,  727.,  728.,
      731.,  732.,  739.,  740.,  743.,  744.,  787.,  788.,  791.,  792.,
      799.,  800.,  803.,  804.,  997.,  998.,  1001., 1002., 1009., 1010.,
      1013., 1014., 1057., 1058., 1061., 1062., 1069., 1070., 1073., 1074.,
      1177., 1178., 1181., 1182., 1189., 1190., 1193., 1194., 1237., 1238.,
      1241., 1242., 1249., 1250., 1253., 1254.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      161.,  162.,  169.,  170.,  281.,  282.,  289.,  290.,
      611.,  612.,  619.,  620.,  731.,  732.,  739.,  740.,
      1061., 1062., 1069., 1070., 1181., 1182., 1189., 1190.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {193.,
                                         194.,
                                         195.,
                                         196.,
                                         201.,
                                         202.,
                                         203.,
                                         204.,
                                         217.,
                                         218.,
                                         219.,
                                         220.,
                                         225.,
                                         226.,
                                         227.,
                                         228.,
                                         313.,
                                         314.,
                                         315.,
                                         316.,
                                         321.,
                                         322.,
                                         323.,
                                         324.,
                                         337.,
                                         338.,
                                         339.,
                                         340.,
                                         345.,
                                         346.,
                                         347.,
                                         348.,
                                         553.,
                                         554.,
                                         555.,
                                         556.,
                                         561.,
                                         562.,
                                         563.,
                                         564.,
                                         577.,
                                         578.,
                                         579.,
                                         580.,
                                         585.,
                                         586.,
                                         587.,
                                         588.,
                                         673.,
                                         674.,
                                         675.,
                                         676.,
                                         681.,
                                         682.,
                                         683.,
                                         684.,
                                         697.,
                                         698.,
                                         699.,
                                         700.,
                                         705.,
                                         706.,
                                         707.,
                                         708.,
                                         1093.,
                                         1094.,
                                         1095.,
                                         1096.,
                                         1101.,
                                         1102.,
                                         1103.,
                                         1104.,
                                         1117.,
                                         1118.,
                                         1119.,
                                         1120.,
                                         1125.,
                                         1126.,
                                         1127.,
                                         1128.,
                                         1213.,
                                         1214.,
                                         1215.,
                                         1216.,
                                         1221.,
                                         1222.,
                                         1223.,
                                         1224.,
                                         1237.,
                                         1238.,
                                         1239.,
                                         1240.,
                                         1245.,
                                         1246.,
                                         1247.,
                                         1248.,
                                         1453.,
                                         1454.,
                                         1455.,
                                         1456.,
                                         1461.,
                                         1462.,
                                         1463.,
                                         1464.,
                                         1477.,
                                         1478.,
                                         1479.,
                                         1480.,
                                         1485.,
                                         1486.,
                                         1487.,
                                         1488.,
                                         1573.,
                                         1574.,
                                         1575.,
                                         1576.,
                                         1581.,
                                         1582.,
                                         1583.,
                                         1584.,
                                         1597.,
                                         1598.,
                                         1599.,
                                         1600.,
                                         1605.,
                                         1606.,
                                         1607.,
                                         1608.,
                                         1198.8775510204082,
                                         1199.8775510204082,
                                         1200.8775510204082,
                                         1201.8775510204082,
                                         1176.4805194805194,
                                         1177.4805194805194,
                                         1178.4805194805194,
                                         1179.4805194805194,
                                         1139.2857142857142,
                                         1140.2857142857142,
                                         1141.2857142857142,
                                         1142.2857142857142,
                                         1147.2857142857142,
                                         1148.2857142857142,
                                         1149.2857142857142,
                                         1150.2857142857142,
                                         862.922077922078,
                                         863.922077922078,
                                         864.922077922078,
                                         865.922077922078,
                                         851.5785123966942,
                                         852.5785123966942,
                                         853.5785123966942,
                                         854.5785123966942,
                                         833.7272727272727,
                                         834.7272727272727,
                                         835.7272727272727,
                                         836.7272727272727,
                                         841.7272727272727,
                                         842.7272727272727,
                                         843.7272727272727,
                                         844.7272727272727,
                                         358.1948051948052,
                                         359.1948051948052,
                                         360.1948051948052,
                                         361.1948051948052,
                                         346.8512396694215,
                                         347.8512396694215,
                                         348.8512396694215,
                                         349.8512396694215,
                                         329.,
                                         330.,
                                         331.,
                                         332.,
                                         337.,
                                         338.,
                                         339.,
                                         340.,
                                         425.,
                                         426.,
                                         427.,
                                         428.,
                                         433.,
                                         434.,
                                         435.,
                                         436.,
                                         449.,
                                         450.,
                                         451.,
                                         452.,
                                         457.,
                                         458.,
                                         459.,
                                         460.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {321.,
                                         322.,
                                         323.,
                                         324.,
                                         337.,
                                         338.,
                                         339.,
                                         340.,
                                         561.,
                                         562.,
                                         563.,
                                         564.,
                                         577.,
                                         578.,
                                         579.,
                                         580.,
                                         1221.,
                                         1222.,
                                         1223.,
                                         1224.,
                                         1237.,
                                         1238.,
                                         1239.,
                                         1240.,
                                         1461.,
                                         1462.,
                                         1463.,
                                         1464.,
                                         1477.,
                                         1478.,
                                         1479.,
                                         1480.,
                                         851.5785123966942,
                                         852.5785123966942,
                                         853.5785123966942,
                                         854.5785123966942,
                                         833.7272727272727,
                                         834.7272727272727,
                                         835.7272727272727,
                                         836.7272727272727,
                                         346.8512396694215,
                                         347.8512396694215,
                                         348.8512396694215,
                                         349.8512396694215,
                                         329.,
                                         330.,
                                         331.,
                                         332.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.5,  55.,  59.,   61.,  84.5,  87.,  91.,   93.,  148.5, 151.,
      155.,  157., 180.5, 183., 187.,  189., 292.5, 295., 299.,  301.,
      324.5, 327., 331.,  333., 388.5, 391., 395.,  397., 420.5, 423.,
      427.,  429., 532.5, 535., 539.,  541., 564.5, 567., 571.,  573.,
      628.5, 631., 635.,  637., 660.5, 663., 667.,  669.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {86.,  90.,  150., 154., 326., 330.,
                                         390., 394., 566., 570., 630., 634.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      104.,  105.,  109.,  110.,  117.,  118.,  121.,  122.,  168.,  169.,
      173.,  174.,  181.,  182.,  185.,  186.,  296.,  297.,  301.,  302.,
      309.,  310.,  313.,  314.,  360.,  361.,  365.,  366.,  373.,  374.,
      377.,  378.,  584.,  585.,  589.,  590.,  597.,  598.,  601.,  602.,
      648.,  649.,  653.,  654.,  661.,  662.,  665.,  666.,  776.,  777.,
      781.,  782.,  789.,  790.,  793.,  794.,  840.,  841.,  845.,  846.,
      853.,  854.,  857.,  858.,  1064., 1065., 1069., 1070., 1077., 1078.,
      1081., 1082., 1128., 1129., 1133., 1134., 1141., 1142., 1145., 1146.,
      1256., 1257., 1261., 1262., 1269., 1270., 1273., 1274., 1320., 1321.,
      1325., 1326., 1333., 1334., 1337., 1338.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      171.,  172.,  179.,  180.,  299.,  300.,  307.,  308.,
      651.,  652.,  659.,  660.,  779.,  780.,  787.,  788.,
      1131., 1132., 1139., 1140., 1259., 1260., 1267., 1268.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {207.,
                                         208.,
                                         209.,
                                         210.,
                                         217.,
                                         218.,
                                         219.,
                                         220.,
                                         233.,
                                         234.,
                                         235.,
                                         236.,
                                         241.,
                                         242.,
                                         243.,
                                         244.,
                                         335.,
                                         336.,
                                         337.,
                                         338.,
                                         345.,
                                         346.,
                                         347.,
                                         348.,
                                         361.,
                                         362.,
                                         363.,
                                         364.,
                                         369.,
                                         370.,
                                         371.,
                                         372.,
                                         591.,
                                         592.,
                                         593.,
                                         594.,
                                         601.,
                                         602.,
                                         603.,
                                         604.,
                                         617.,
                                         618.,
                                         619.,
                                         620.,
                                         625.,
                                         626.,
                                         627.,
                                         628.,
                                         719.,
                                         720.,
                                         721.,
                                         722.,
                                         729.,
                                         730.,
                                         731.,
                                         732.,
                                         745.,
                                         746.,
                                         747.,
                                         748.,
                                         753.,
                                         754.,
                                         755.,
                                         756.,
                                         1167.,
                                         1168.,
                                         1169.,
                                         1170.,
                                         1177.,
                                         1178.,
                                         1179.,
                                         1180.,
                                         1193.,
                                         1194.,
                                         1195.,
                                         1196.,
                                         1201.,
                                         1202.,
                                         1203.,
                                         1204.,
                                         1295.,
                                         1296.,
                                         1297.,
                                         1298.,
                                         1305.,
                                         1306.,
                                         1307.,
                                         1308.,
                                         1321.,
                                         1322.,
                                         1323.,
                                         1324.,
                                         1329.,
                                         1330.,
                                         1331.,
                                         1332.,
                                         1551.,
                                         1552.,
                                         1553.,
                                         1554.,
                                         1561.,
                                         1562.,
                                         1563.,
                                         1564.,
                                         1577.,
                                         1578.,
                                         1579.,
                                         1580.,
                                         1585.,
                                         1586.,
                                         1587.,
                                         1588.,
                                         1679.,
                                         1680.,
                                         1681.,
                                         1682.,
                                         1689.,
                                         1690.,
                                         1691.,
                                         1692.,
                                         1705.,
                                         1706.,
                                         1707.,
                                         1708.,
                                         1713.,
                                         1714.,
                                         1715.,
                                         1716.,
                                         664.1428571428571,
                                         665.1428571428571,
                                         666.1428571428571,
                                         667.1428571428571,
                                         674.1428571428571,
                                         675.1428571428571,
                                         676.1428571428571,
                                         677.1428571428571,
                                         690.1428571428571,
                                         691.1428571428571,
                                         692.1428571428571,
                                         693.1428571428571,
                                         698.1428571428571,
                                         699.1428571428571,
                                         700.1428571428571,
                                         701.1428571428571,
                                         579.3636363636364,
                                         580.3636363636364,
                                         581.3636363636364,
                                         582.3636363636364,
                                         589.3636363636364,
                                         590.3636363636364,
                                         591.3636363636364,
                                         592.3636363636364,
                                         605.3636363636364,
                                         606.3636363636364,
                                         607.3636363636364,
                                         608.3636363636364,
                                         613.3636363636364,
                                         614.3636363636364,
                                         615.3636363636364,
                                         616.3636363636364,
                                         463.,
                                         464.,
                                         465.,
                                         466.,
                                         473.,
                                         474.,
                                         475.,
                                         476.,
                                         489.,
                                         490.,
                                         491.,
                                         492.,
                                         497.,
                                         498.,
                                         499.,
                                         500.,
                                         591.,
                                         592.,
                                         593.,
                                         594.,
                                         601.,
                                         602.,
                                         603.,
                                         604.,
                                         617.,
                                         618.,
                                         619.,
                                         620.,
                                         625.,
                                         626.,
                                         627.,
                                         628.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {341.,
                                         342.,
                                         343.,
                                         344.,
                                         357.,
                                         358.,
                                         359.,
                                         360.,
                                         597.,
                                         598.,
                                         599.,
                                         600.,
                                         613.,
                                         614.,
                                         615.,
                                         616.,
                                         1301.,
                                         1302.,
                                         1303.,
                                         1304.,
                                         1317.,
                                         1318.,
                                         1319.,
                                         1320.,
                                         1557.,
                                         1558.,
                                         1559.,
                                         1560.,
                                         1573.,
                                         1574.,
                                         1575.,
                                         1576.,
                                         585.3636363636364,
                                         586.3636363636364,
                                         587.3636363636364,
                                         588.3636363636364,
                                         601.3636363636364,
                                         602.3636363636364,
                                         603.3636363636364,
                                         604.3636363636364,
                                         469.,
                                         470.,
                                         471.,
                                         472.,
                                         485.,
                                         486.,
                                         487.,
                                         488.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58.,  60.,  64.,  67.5,  69.5,  94.,  96.,  100., 103.5, 105.5,
      166., 168., 172., 175.5, 177.5, 202., 204., 208., 211.5, 213.5,
      328., 330., 334., 337.5, 339.5, 364., 366., 370., 373.5, 375.5,
      436., 438., 442., 445.5, 447.5, 472., 474., 478., 481.5, 483.5,
      598., 600., 604., 607.5, 609.5, 634., 636., 640., 643.5, 645.5,
      706., 708., 712., 715.5, 717.5, 742., 744., 748., 751.5, 753.5};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {96.,  100., 168., 172., 366., 370.,
                                         438., 442., 636., 640., 708., 712.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115.,  116.,  119.,  120.,  127.,  128.,  134.,  135.,  138.,  139.,
      187.,  188.,  191.,  192.,  199.,  200.,  206.,  207.,  210.,  211.,
      331.,  332.,  335.,  336.,  343.,  344.,  350.,  351.,  354.,  355.,
      403.,  404.,  407.,  408.,  415.,  416.,  422.,  423.,  426.,  427.,
      655.,  656.,  659.,  660.,  667.,  668.,  674.,  675.,  678.,  679.,
      727.,  728.,  731.,  732.,  739.,  740.,  746.,  747.,  750.,  751.,
      871.,  872.,  875.,  876.,  883.,  884.,  890.,  891.,  894.,  895.,
      943.,  944.,  947.,  948.,  955.,  956.,  962.,  963.,  966.,  967.,
      1195., 1196., 1199., 1200., 1207., 1208., 1214., 1215., 1218., 1219.,
      1267., 1268., 1271., 1272., 1279., 1280., 1286., 1287., 1290., 1291.,
      1411., 1412., 1415., 1416., 1423., 1424., 1430., 1431., 1434., 1435.,
      1483., 1484., 1487., 1488., 1495., 1496., 1502., 1503., 1506., 1507.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      191.,  192.,  199.,  200.,  335.,  336.,  343.,  344.,
      731.,  732.,  739.,  740.,  875.,  876.,  883.,  884.,
      1271., 1272., 1279., 1280., 1415., 1416., 1423., 1424.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x15x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {229.,
                                         230.,
                                         231.,
                                         232.,
                                         237.,
                                         238.,
                                         239.,
                                         240.,
                                         253.,
                                         254.,
                                         255.,
                                         256.,
                                         267.,
                                         268.,
                                         269.,
                                         270.,
                                         275.,
                                         276.,
                                         277.,
                                         278.,
                                         373.,
                                         374.,
                                         375.,
                                         376.,
                                         381.,
                                         382.,
                                         383.,
                                         384.,
                                         397.,
                                         398.,
                                         399.,
                                         400.,
                                         411.,
                                         412.,
                                         413.,
                                         414.,
                                         419.,
                                         420.,
                                         421.,
                                         422.,
                                         661.,
                                         662.,
                                         663.,
                                         664.,
                                         669.,
                                         670.,
                                         671.,
                                         672.,
                                         685.,
                                         686.,
                                         687.,
                                         688.,
                                         699.,
                                         700.,
                                         701.,
                                         702.,
                                         707.,
                                         708.,
                                         709.,
                                         710.,
                                         805.,
                                         806.,
                                         807.,
                                         808.,
                                         813.,
                                         814.,
                                         815.,
                                         816.,
                                         829.,
                                         830.,
                                         831.,
                                         832.,
                                         843.,
                                         844.,
                                         845.,
                                         846.,
                                         851.,
                                         852.,
                                         853.,
                                         854.,
                                         1309.,
                                         1310.,
                                         1311.,
                                         1312.,
                                         1317.,
                                         1318.,
                                         1319.,
                                         1320.,
                                         1333.,
                                         1334.,
                                         1335.,
                                         1336.,
                                         1347.,
                                         1348.,
                                         1349.,
                                         1350.,
                                         1355.,
                                         1356.,
                                         1357.,
                                         1358.,
                                         1453.,
                                         1454.,
                                         1455.,
                                         1456.,
                                         1461.,
                                         1462.,
                                         1463.,
                                         1464.,
                                         1477.,
                                         1478.,
                                         1479.,
                                         1480.,
                                         1491.,
                                         1492.,
                                         1493.,
                                         1494.,
                                         1499.,
                                         1500.,
                                         1501.,
                                         1502.,
                                         1554.8181818181818,
                                         1555.8181818181818,
                                         1556.8181818181818,
                                         1557.8181818181818,
                                         1512.0413223140497,
                                         1513.0413223140497,
                                         1514.0413223140497,
                                         1515.0413223140497,
                                         1460.3388429752067,
                                         1461.3388429752067,
                                         1462.3388429752067,
                                         1463.3388429752067,
                                         1406.6363636363637,
                                         1407.6363636363637,
                                         1408.6363636363637,
                                         1409.6363636363637,
                                         1414.6363636363637,
                                         1415.6363636363637,
                                         1416.6363636363637,
                                         1417.6363636363637,
                                         1592.4285714285713,
                                         1593.4285714285713,
                                         1594.4285714285713,
                                         1595.4285714285713,
                                         1520.6363636363637,
                                         1521.6363636363637,
                                         1522.6363636363637,
                                         1523.6363636363637,
                                         1430.2467532467533,
                                         1431.2467532467533,
                                         1432.2467532467533,
                                         1433.2467532467533,
                                         1337.857142857143,
                                         1338.857142857143,
                                         1339.857142857143,
                                         1340.857142857143,
                                         1345.857142857143,
                                         1346.857142857143,
                                         1347.857142857143,
                                         1348.857142857143,
                                         341.,
                                         342.,
                                         343.,
                                         344.,
                                         349.,
                                         350.,
                                         351.,
                                         352.,
                                         365.,
                                         366.,
                                         367.,
                                         368.,
                                         379.,
                                         380.,
                                         381.,
                                         382.,
                                         387.,
                                         388.,
                                         389.,
                                         390.,
                                         485.,
                                         486.,
                                         487.,
                                         488.,
                                         493.,
                                         494.,
                                         495.,
                                         496.,
                                         509.,
                                         510.,
                                         511.,
                                         512.,
                                         523.,
                                         524.,
                                         525.,
                                         526.,
                                         531.,
                                         532.,
                                         533.,
                                         534.,
                                         773.,
                                         774.,
                                         775.,
                                         776.,
                                         781.,
                                         782.,
                                         783.,
                                         784.,
                                         797.,
                                         798.,
                                         799.,
                                         800.,
                                         811.,
                                         812.,
                                         813.,
                                         814.,
                                         819.,
                                         820.,
                                         821.,
                                         822.,
                                         917.,
                                         918.,
                                         919.,
                                         920.,
                                         925.,
                                         926.,
                                         927.,
                                         928.,
                                         941.,
                                         942.,
                                         943.,
                                         944.,
                                         955.,
                                         956.,
                                         957.,
                                         958.,
                                         963.,
                                         964.,
                                         965.,
                                         966.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x15x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381.,
                                         382.,
                                         383.,
                                         384.,
                                         397.,
                                         398.,
                                         399.,
                                         400.,
                                         669.,
                                         670.,
                                         671.,
                                         672.,
                                         685.,
                                         686.,
                                         687.,
                                         688.,
                                         1461.,
                                         1462.,
                                         1463.,
                                         1464.,
                                         1477.,
                                         1478.,
                                         1479.,
                                         1480.,
                                         1512.0413223140497,
                                         1513.0413223140497,
                                         1514.0413223140497,
                                         1515.0413223140497,
                                         1460.3388429752067,
                                         1461.3388429752067,
                                         1462.3388429752067,
                                         1463.3388429752067,
                                         493.,
                                         494.,
                                         495.,
                                         496.,
                                         509.,
                                         510.,
                                         511.,
                                         512.,
                                         781.,
                                         782.,
                                         783.,
                                         784.,
                                         797.,
                                         798.,
                                         799.,
                                         800.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      56.5, 58.5, 62.5,  64.5,  94.,   96.,   100.,  102.,  154.,  156.,
      160., 162., 184.,  186.,  190.,  192.,  296.5, 298.5, 302.5, 304.5,
      334., 336., 340.,  342.,  394.,  396.,  400.,  402.,  424.,  426.,
      430., 432., 536.5, 538.5, 542.5, 544.5, 574.,  576.,  580.,  582.,
      634., 636., 640.,  642.,  664.,  666.,  670.,  672.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {81.,  85.,  141., 145., 321., 325.,
                                         381., 385., 561., 565., 621., 625.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      112.,  113.,  116.,  117.,  124.,  125.,  128.,  129.,  187.,  188.,
      191.,  192.,  199.,  200.,  203.,  204.,  307.,  308.,  311.,  312.,
      319.,  320.,  323.,  324.,  367.,  368.,  371.,  372.,  379.,  380.,
      383.,  384.,  592.,  593.,  596.,  597.,  604.,  605.,  608.,  609.,
      667.,  668.,  671.,  672.,  679.,  680.,  683.,  684.,  787.,  788.,
      791.,  792.,  799.,  800.,  803.,  804.,  847.,  848.,  851.,  852.,
      859.,  860.,  863.,  864.,  1072., 1073., 1076., 1077., 1084., 1085.,
      1088., 1089., 1147., 1148., 1151., 1152., 1159., 1160., 1163., 1164.,
      1267., 1268., 1271., 1272., 1279., 1280., 1283., 1284., 1327., 1328.,
      1331., 1332., 1339., 1340., 1343., 1344.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      161.,  162.,  169.,  170.,  281.,  282.,  289.,  290.,
      641.,  642.,  649.,  650.,  761.,  762.,  769.,  770.,
      1121., 1122., 1129., 1130., 1241., 1242., 1249., 1250.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {223.,
                                         224.,
                                         225.,
                                         226.,
                                         231.,
                                         232.,
                                         233.,
                                         234.,
                                         247.,
                                         248.,
                                         249.,
                                         250.,
                                         255.,
                                         256.,
                                         257.,
                                         258.,
                                         373.,
                                         374.,
                                         375.,
                                         376.,
                                         381.,
                                         382.,
                                         383.,
                                         384.,
                                         397.,
                                         398.,
                                         399.,
                                         400.,
                                         405.,
                                         406.,
                                         407.,
                                         408.,
                                         613.,
                                         614.,
                                         615.,
                                         616.,
                                         621.,
                                         622.,
                                         623.,
                                         624.,
                                         637.,
                                         638.,
                                         639.,
                                         640.,
                                         645.,
                                         646.,
                                         647.,
                                         648.,
                                         733.,
                                         734.,
                                         735.,
                                         736.,
                                         741.,
                                         742.,
                                         743.,
                                         744.,
                                         757.,
                                         758.,
                                         759.,
                                         760.,
                                         765.,
                                         766.,
                                         767.,
                                         768.,
                                         1183.,
                                         1184.,
                                         1185.,
                                         1186.,
                                         1191.,
                                         1192.,
                                         1193.,
                                         1194.,
                                         1207.,
                                         1208.,
                                         1209.,
                                         1210.,
                                         1215.,
                                         1216.,
                                         1217.,
                                         1218.,
                                         1333.,
                                         1334.,
                                         1335.,
                                         1336.,
                                         1341.,
                                         1342.,
                                         1343.,
                                         1344.,
                                         1357.,
                                         1358.,
                                         1359.,
                                         1360.,
                                         1365.,
                                         1366.,
                                         1367.,
                                         1368.,
                                         1573.,
                                         1574.,
                                         1575.,
                                         1576.,
                                         1581.,
                                         1582.,
                                         1583.,
                                         1584.,
                                         1597.,
                                         1598.,
                                         1599.,
                                         1600.,
                                         1605.,
                                         1606.,
                                         1607.,
                                         1608.,
                                         1693.,
                                         1694.,
                                         1695.,
                                         1696.,
                                         1701.,
                                         1702.,
                                         1703.,
                                         1704.,
                                         1717.,
                                         1718.,
                                         1719.,
                                         1720.,
                                         1725.,
                                         1726.,
                                         1727.,
                                         1728.,
                                         680.1428571428571,
                                         681.1428571428571,
                                         682.1428571428571,
                                         683.1428571428571,
                                         661.5454545454545,
                                         662.5454545454545,
                                         663.5454545454545,
                                         664.5454545454545,
                                         631.,
                                         632.,
                                         633.,
                                         634.,
                                         639.,
                                         640.,
                                         641.,
                                         642.,
                                         484.3766233766234,
                                         485.3766233766234,
                                         486.3766233766234,
                                         487.3766233766234,
                                         473.0330578512397,
                                         474.0330578512397,
                                         475.0330578512397,
                                         476.0330578512397,
                                         455.1818181818182,
                                         456.1818181818182,
                                         457.1818181818182,
                                         458.1818181818182,
                                         463.1818181818182,
                                         464.1818181818182,
                                         465.1818181818182,
                                         466.1818181818182,
                                         485.,
                                         486.,
                                         487.,
                                         488.,
                                         493.,
                                         494.,
                                         495.,
                                         496.,
                                         509.,
                                         510.,
                                         511.,
                                         512.,
                                         517.,
                                         518.,
                                         519.,
                                         520.,
                                         605.,
                                         606.,
                                         607.,
                                         608.,
                                         613.,
                                         614.,
                                         615.,
                                         616.,
                                         629.,
                                         630.,
                                         631.,
                                         632.,
                                         637.,
                                         638.,
                                         639.,
                                         640.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {321.,
                                         322.,
                                         323.,
                                         324.,
                                         337.,
                                         338.,
                                         339.,
                                         340.,
                                         561.,
                                         562.,
                                         563.,
                                         564.,
                                         577.,
                                         578.,
                                         579.,
                                         580.,
                                         1281.,
                                         1282.,
                                         1283.,
                                         1284.,
                                         1297.,
                                         1298.,
                                         1299.,
                                         1300.,
                                         1521.,
                                         1522.,
                                         1523.,
                                         1524.,
                                         1537.,
                                         1538.,
                                         1539.,
                                         1540.,
                                         599.2148760330579,
                                         600.2148760330579,
                                         601.2148760330579,
                                         602.2148760330579,
                                         581.3636363636364,
                                         582.3636363636364,
                                         583.3636363636364,
                                         584.3636363636364,
                                         433.,
                                         434.,
                                         435.,
                                         436.,
                                         449.,
                                         450.,
                                         451.,
                                         452.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60.5,  63.,  67.,   69.,  100.5, 103., 107.,  109., 164.5, 167.,
      171.,  173., 196.5, 199., 203.,  205., 316.5, 319., 323.,  325.,
      356.5, 359., 363.,  365., 420.5, 423., 427.,  429., 452.5, 455.,
      459.,  461., 572.5, 575., 579.,  581., 612.5, 615., 619.,  621.,
      676.5, 679., 683.,  685., 708.5, 711., 715.,  717.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {86.,  90.,  150., 154., 342., 346.,
                                         406., 410., 598., 602., 662., 666.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120.,  121.,  125.,  126.,  133.,  134.,  137.,  138.,  200.,  201.,
      205.,  206.,  213.,  214.,  217.,  218.,  328.,  329.,  333.,  334.,
      341.,  342.,  345.,  346.,  392.,  393.,  397.,  398.,  405.,  406.,
      409.,  410.,  632.,  633.,  637.,  638.,  645.,  646.,  649.,  650.,
      712.,  713.,  717.,  718.,  725.,  726.,  729.,  730.,  840.,  841.,
      845.,  846.,  853.,  854.,  857.,  858.,  904.,  905.,  909.,  910.,
      917.,  918.,  921.,  922.,  1144., 1145., 1149., 1150., 1157., 1158.,
      1161., 1162., 1224., 1225., 1229., 1230., 1237., 1238., 1241., 1242.,
      1352., 1353., 1357., 1358., 1365., 1366., 1369., 1370., 1416., 1417.,
      1421., 1422., 1429., 1430., 1433., 1434.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      171.,  172.,  179.,  180.,  299.,  300.,  307.,  308.,
      683.,  684.,  691.,  692.,  811.,  812.,  819.,  820.,
      1195., 1196., 1203., 1204., 1323., 1324., 1331., 1332.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      239.,  240.,  241.,  242.,  249.,  250.,  251.,  252.,  265.,  266.,
      267.,  268.,  273.,  274.,  275.,  276.,  399.,  400.,  401.,  402.,
      409.,  410.,  411.,  412.,  425.,  426.,  427.,  428.,  433.,  434.,
      435.,  436.,  655.,  656.,  657.,  658.,  665.,  666.,  667.,  668.,
      681.,  682.,  683.,  684.,  689.,  690.,  691.,  692.,  783.,  784.,
      785.,  786.,  793.,  794.,  795.,  796.,  809.,  810.,  811.,  812.,
      817.,  818.,  819.,  820.,  1263., 1264., 1265., 1266., 1273., 1274.,
      1275., 1276., 1289., 1290., 1291., 1292., 1297., 1298., 1299., 1300.,
      1423., 1424., 1425., 1426., 1433., 1434., 1435., 1436., 1449., 1450.,
      1451., 1452., 1457., 1458., 1459., 1460., 1679., 1680., 1681., 1682.,
      1689., 1690., 1691., 1692., 1705., 1706., 1707., 1708., 1713., 1714.,
      1715., 1716., 1807., 1808., 1809., 1810., 1817., 1818., 1819., 1820.,
      1833., 1834., 1835., 1836., 1841., 1842., 1843., 1844., 239.,  240.,
      241.,  242.,  249.,  250.,  251.,  252.,  265.,  266.,  267.,  268.,
      273.,  274.,  275.,  276.,  399.,  400.,  401.,  402.,  409.,  410.,
      411.,  412.,  425.,  426.,  427.,  428.,  433.,  434.,  435.,  436.,
      655.,  656.,  657.,  658.,  665.,  666.,  667.,  668.,  681.,  682.,
      683.,  684.,  689.,  690.,  691.,  692.,  783.,  784.,  785.,  786.,
      793.,  794.,  795.,  796.,  809.,  810.,  811.,  812.,  817.,  818.,
      819.,  820.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      341.,  342.,  343.,  344.,  357.,  358.,  359.,  360.,  597.,  598.,
      599.,  600.,  613.,  614.,  615.,  616.,  1365., 1366., 1367., 1368.,
      1381., 1382., 1383., 1384., 1621., 1622., 1623., 1624., 1637., 1638.,
      1639., 1640., 341.,  342.,  343.,  344.,  357.,  358.,  359.,  360.,
      597.,  598.,  599.,  600.,  613.,  614.,  615.,  616.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  69.,  73.,  76.5,  78.5,  112., 114., 118., 121.5, 123.5,
      184., 186., 190., 193.5, 195.5, 220., 222., 226., 229.5, 231.5,
      355., 357., 361., 364.5, 366.5, 400., 402., 406., 409.5, 411.5,
      472., 474., 478., 481.5, 483.5, 508., 510., 514., 517.5, 519.5,
      643., 645., 649., 652.5, 654.5, 688., 690., 694., 697.5, 699.5,
      760., 762., 766., 769.5, 771.5, 796., 798., 802., 805.5, 807.5};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {96.,  100., 168., 172., 384., 388.,
                                         456., 460., 672., 676., 744., 748.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133.,  134.,  137.,  138.,  145.,  146.,  152.,  153.,  156.,  157.,
      223.,  224.,  227.,  228.,  235.,  236.,  242.,  243.,  246.,  247.,
      367.,  368.,  371.,  372.,  379.,  380.,  386.,  387.,  390.,  391.,
      439.,  440.,  443.,  444.,  451.,  452.,  458.,  459.,  462.,  463.,
      709.,  710.,  713.,  714.,  721.,  722.,  728.,  729.,  732.,  733.,
      799.,  800.,  803.,  804.,  811.,  812.,  818.,  819.,  822.,  823.,
      943.,  944.,  947.,  948.,  955.,  956.,  962.,  963.,  966.,  967.,
      1015., 1016., 1019., 1020., 1027., 1028., 1034., 1035., 1038., 1039.,
      1285., 1286., 1289., 1290., 1297., 1298., 1304., 1305., 1308., 1309.,
      1375., 1376., 1379., 1380., 1387., 1388., 1394., 1395., 1398., 1399.,
      1519., 1520., 1523., 1524., 1531., 1532., 1538., 1539., 1542., 1543.,
      1591., 1592., 1595., 1596., 1603., 1604., 1610., 1611., 1614., 1615.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      191.,  192.,  199.,  200.,  335.,  336.,  343.,  344.,
      767.,  768.,  775.,  776.,  911.,  912.,  919.,  920.,
      1343., 1344., 1351., 1352., 1487., 1488., 1495., 1496.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x16x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {265.,
                                         266.,
                                         267.,
                                         268.,
                                         273.,
                                         274.,
                                         275.,
                                         276.,
                                         289.,
                                         290.,
                                         291.,
                                         292.,
                                         303.,
                                         304.,
                                         305.,
                                         306.,
                                         311.,
                                         312.,
                                         313.,
                                         314.,
                                         445.,
                                         446.,
                                         447.,
                                         448.,
                                         453.,
                                         454.,
                                         455.,
                                         456.,
                                         469.,
                                         470.,
                                         471.,
                                         472.,
                                         483.,
                                         484.,
                                         485.,
                                         486.,
                                         491.,
                                         492.,
                                         493.,
                                         494.,
                                         733.,
                                         734.,
                                         735.,
                                         736.,
                                         741.,
                                         742.,
                                         743.,
                                         744.,
                                         757.,
                                         758.,
                                         759.,
                                         760.,
                                         771.,
                                         772.,
                                         773.,
                                         774.,
                                         779.,
                                         780.,
                                         781.,
                                         782.,
                                         877.,
                                         878.,
                                         879.,
                                         880.,
                                         885.,
                                         886.,
                                         887.,
                                         888.,
                                         901.,
                                         902.,
                                         903.,
                                         904.,
                                         915.,
                                         916.,
                                         917.,
                                         918.,
                                         923.,
                                         924.,
                                         925.,
                                         926.,
                                         1417.,
                                         1418.,
                                         1419.,
                                         1420.,
                                         1425.,
                                         1426.,
                                         1427.,
                                         1428.,
                                         1441.,
                                         1442.,
                                         1443.,
                                         1444.,
                                         1455.,
                                         1456.,
                                         1457.,
                                         1458.,
                                         1463.,
                                         1464.,
                                         1465.,
                                         1466.,
                                         1597.,
                                         1598.,
                                         1599.,
                                         1600.,
                                         1605.,
                                         1606.,
                                         1607.,
                                         1608.,
                                         1621.,
                                         1622.,
                                         1623.,
                                         1624.,
                                         1635.,
                                         1636.,
                                         1637.,
                                         1638.,
                                         1643.,
                                         1644.,
                                         1645.,
                                         1646.,
                                         1326.4545454545455,
                                         1327.4545454545455,
                                         1328.4545454545455,
                                         1329.4545454545455,
                                         1283.6776859504132,
                                         1284.6776859504132,
                                         1285.6776859504132,
                                         1286.6776859504132,
                                         1231.9752066115702,
                                         1232.9752066115702,
                                         1233.9752066115702,
                                         1234.9752066115702,
                                         1178.2727272727273,
                                         1179.2727272727273,
                                         1180.2727272727273,
                                         1181.2727272727273,
                                         1186.2727272727273,
                                         1187.2727272727273,
                                         1188.2727272727273,
                                         1189.2727272727273,
                                         1151.2857142857142,
                                         1152.2857142857142,
                                         1153.2857142857142,
                                         1154.2857142857142,
                                         1079.4935064935064,
                                         1080.4935064935064,
                                         1081.4935064935064,
                                         1082.4935064935064,
                                         989.1038961038961,
                                         990.1038961038961,
                                         991.1038961038961,
                                         992.1038961038961,
                                         896.7142857142857,
                                         897.7142857142857,
                                         898.7142857142857,
                                         899.7142857142857,
                                         904.7142857142857,
                                         905.7142857142857,
                                         906.7142857142857,
                                         907.7142857142857,
                                         521.,
                                         522.,
                                         523.,
                                         524.,
                                         529.,
                                         530.,
                                         531.,
                                         532.,
                                         545.,
                                         546.,
                                         547.,
                                         548.,
                                         559.,
                                         560.,
                                         561.,
                                         562.,
                                         567.,
                                         568.,
                                         569.,
                                         570.,
                                         701.,
                                         702.,
                                         703.,
                                         704.,
                                         709.,
                                         710.,
                                         711.,
                                         712.,
                                         725.,
                                         726.,
                                         727.,
                                         728.,
                                         739.,
                                         740.,
                                         741.,
                                         742.,
                                         747.,
                                         748.,
                                         749.,
                                         750.,
                                         989.,
                                         990.,
                                         991.,
                                         992.,
                                         997.,
                                         998.,
                                         999.,
                                         1000.,
                                         1013.,
                                         1014.,
                                         1015.,
                                         1016.,
                                         1027.,
                                         1028.,
                                         1029.,
                                         1030.,
                                         1035.,
                                         1036.,
                                         1037.,
                                         1038.,
                                         1133.,
                                         1134.,
                                         1135.,
                                         1136.,
                                         1141.,
                                         1142.,
                                         1143.,
                                         1144.,
                                         1157.,
                                         1158.,
                                         1159.,
                                         1160.,
                                         1171.,
                                         1172.,
                                         1173.,
                                         1174.,
                                         1179.,
                                         1180.,
                                         1181.,
                                         1182.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x16x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381.,
                                         382.,
                                         383.,
                                         384.,
                                         397.,
                                         398.,
                                         399.,
                                         400.,
                                         669.,
                                         670.,
                                         671.,
                                         672.,
                                         685.,
                                         686.,
                                         687.,
                                         688.,
                                         1533.,
                                         1534.,
                                         1535.,
                                         1536.,
                                         1549.,
                                         1550.,
                                         1551.,
                                         1552.,
                                         1397.8595041322315,
                                         1398.8595041322315,
                                         1399.8595041322315,
                                         1400.8595041322315,
                                         1346.1570247933885,
                                         1347.1570247933885,
                                         1348.1570247933885,
                                         1349.1570247933885,
                                         637.,
                                         638.,
                                         639.,
                                         640.,
                                         653.,
                                         654.,
                                         655.,
                                         656.,
                                         925.,
                                         926.,
                                         927.,
                                         928.,
                                         941.,
                                         942.,
                                         943.,
                                         944.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  51.,  55.,   57.,   79.,   81.,   85.,   87.,   139.,  141.,
      145., 147., 191.5, 193.5, 197.5, 199.5, 221.5, 223.5, 227.5, 229.5,
      319., 321., 325.,  327.,  349.,  351.,  355.,  357.,  409.,  411.,
      415., 417., 461.5, 463.5, 467.5, 469.5, 491.5, 493.5, 497.5, 499.5,
      589., 591., 595.,  597.,  619.,  621.,  625.,  627.,  679.,  681.,
      685., 687., 731.5, 733.5, 737.5, 739.5, 761.5, 763.5, 767.5, 769.5};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x15x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {81.,  85.,  141., 145., 351., 355.,
                                         411., 415., 621., 625., 681., 685.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,   98.,   101.,  102.,  109.,  110.,  113.,  114.,  157.,  158.,
      161.,  162.,  169.,  170.,  173.,  174.,  277.,  278.,  281.,  282.,
      289.,  290.,  293.,  294.,  382.,  383.,  386.,  387.,  394.,  395.,
      398.,  399.,  442.,  443.,  446.,  447.,  454.,  455.,  458.,  459.,
      637.,  638.,  641.,  642.,  649.,  650.,  653.,  654.,  697.,  698.,
      701.,  702.,  709.,  710.,  713.,  714.,  817.,  818.,  821.,  822.,
      829.,  830.,  833.,  834.,  922.,  923.,  926.,  927.,  934.,  935.,
      938.,  939.,  982.,  983.,  986.,  987.,  994.,  995.,  998.,  999.,
      1177., 1178., 1181., 1182., 1189., 1190., 1193., 1194., 1237., 1238.,
      1241., 1242., 1249., 1250., 1253., 1254., 1357., 1358., 1361., 1362.,
      1369., 1370., 1373., 1374., 1462., 1463., 1466., 1467., 1474., 1475.,
      1478., 1479., 1522., 1523., 1526., 1527., 1534., 1535., 1538., 1539.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x15x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      161.,  162.,  169.,  170.,  281.,  282.,  289.,  290.,
      701.,  702.,  709.,  710.,  821.,  822.,  829.,  830.,
      1241., 1242., 1249., 1250., 1361., 1362., 1369., 1370.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {193.,
                                         194.,
                                         195.,
                                         196.,
                                         201.,
                                         202.,
                                         203.,
                                         204.,
                                         217.,
                                         218.,
                                         219.,
                                         220.,
                                         225.,
                                         226.,
                                         227.,
                                         228.,
                                         313.,
                                         314.,
                                         315.,
                                         316.,
                                         321.,
                                         322.,
                                         323.,
                                         324.,
                                         337.,
                                         338.,
                                         339.,
                                         340.,
                                         345.,
                                         346.,
                                         347.,
                                         348.,
                                         553.,
                                         554.,
                                         555.,
                                         556.,
                                         561.,
                                         562.,
                                         563.,
                                         564.,
                                         577.,
                                         578.,
                                         579.,
                                         580.,
                                         585.,
                                         586.,
                                         587.,
                                         588.,
                                         763.,
                                         764.,
                                         765.,
                                         766.,
                                         771.,
                                         772.,
                                         773.,
                                         774.,
                                         787.,
                                         788.,
                                         789.,
                                         790.,
                                         795.,
                                         796.,
                                         797.,
                                         798.,
                                         883.,
                                         884.,
                                         885.,
                                         886.,
                                         891.,
                                         892.,
                                         893.,
                                         894.,
                                         907.,
                                         908.,
                                         909.,
                                         910.,
                                         915.,
                                         916.,
                                         917.,
                                         918.,
                                         1273.,
                                         1274.,
                                         1275.,
                                         1276.,
                                         1281.,
                                         1282.,
                                         1283.,
                                         1284.,
                                         1297.,
                                         1298.,
                                         1299.,
                                         1300.,
                                         1305.,
                                         1306.,
                                         1307.,
                                         1308.,
                                         1393.,
                                         1394.,
                                         1395.,
                                         1396.,
                                         1401.,
                                         1402.,
                                         1403.,
                                         1404.,
                                         1417.,
                                         1418.,
                                         1419.,
                                         1420.,
                                         1425.,
                                         1426.,
                                         1427.,
                                         1428.,
                                         1633.,
                                         1634.,
                                         1635.,
                                         1636.,
                                         1641.,
                                         1642.,
                                         1643.,
                                         1644.,
                                         1657.,
                                         1658.,
                                         1659.,
                                         1660.,
                                         1665.,
                                         1666.,
                                         1667.,
                                         1668.,
                                         1491.9142857142858,
                                         1492.9142857142858,
                                         1493.9142857142858,
                                         1494.9142857142858,
                                         1478.6363636363637,
                                         1479.6363636363637,
                                         1480.6363636363637,
                                         1481.6363636363637,
                                         1457.4,
                                         1458.4,
                                         1459.4,
                                         1460.4,
                                         1465.4,
                                         1466.4,
                                         1467.4,
                                         1468.4,
                                         1377.857142857143,
                                         1378.857142857143,
                                         1379.857142857143,
                                         1380.857142857143,
                                         1350.3939393939395,
                                         1351.3939393939395,
                                         1352.3939393939395,
                                         1353.3939393939395,
                                         1304.3333333333333,
                                         1305.3333333333333,
                                         1306.3333333333333,
                                         1307.3333333333333,
                                         1312.3333333333333,
                                         1313.3333333333333,
                                         1314.3333333333333,
                                         1315.3333333333333,
                                         305.,
                                         306.,
                                         307.,
                                         308.,
                                         313.,
                                         314.,
                                         315.,
                                         316.,
                                         329.,
                                         330.,
                                         331.,
                                         332.,
                                         337.,
                                         338.,
                                         339.,
                                         340.,
                                         425.,
                                         426.,
                                         427.,
                                         428.,
                                         433.,
                                         434.,
                                         435.,
                                         436.,
                                         449.,
                                         450.,
                                         451.,
                                         452.,
                                         457.,
                                         458.,
                                         459.,
                                         460.,
                                         665.,
                                         666.,
                                         667.,
                                         668.,
                                         673.,
                                         674.,
                                         675.,
                                         676.,
                                         689.,
                                         690.,
                                         691.,
                                         692.,
                                         697.,
                                         698.,
                                         699.,
                                         700.,
                                         875.,
                                         876.,
                                         877.,
                                         878.,
                                         883.,
                                         884.,
                                         885.,
                                         886.,
                                         899.,
                                         900.,
                                         901.,
                                         902.,
                                         907.,
                                         908.,
                                         909.,
                                         910.,
                                         995.,
                                         996.,
                                         997.,
                                         998.,
                                         1003.,
                                         1004.,
                                         1005.,
                                         1006.,
                                         1019.,
                                         1020.,
                                         1021.,
                                         1022.,
                                         1027.,
                                         1028.,
                                         1029.,
                                         1030.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x15x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      321.,  322.,  323.,  324.,  337.,  338.,  339.,  340.,  561.,  562.,
      563.,  564.,  577.,  578.,  579.,  580.,  1401., 1402., 1403., 1404.,
      1417., 1418., 1419., 1420., 1641., 1642., 1643., 1644., 1657., 1658.,
      1659., 1660., 433.,  434.,  435.,  436.,  449.,  450.,  451.,  452.,
      673.,  674.,  675.,  676.,  689.,  690.,  691.,  692.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.5,  55.,  59.,   61.,  84.5,  87.,  91.,   93.,  148.5, 151.,
      155.,  157., 204.5, 207., 211.,  213., 236.5, 239., 243.,  245.,
      340.5, 343., 347.,  349., 372.5, 375., 379.,  381., 436.5, 439.,
      443.,  445., 492.5, 495., 499.,  501., 524.5, 527., 531.,  533.,
      628.5, 631., 635.,  637., 660.5, 663., 667.,  669., 724.5, 727.,
      731.,  733., 780.5, 783., 787.,  789., 812.5, 815., 819.,  821.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x16x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {86.,  90.,  150., 154., 374., 378.,
                                         438., 442., 662., 666., 726., 730.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      104.,  105.,  109.,  110.,  117.,  118.,  121.,  122.,  168.,  169.,
      173.,  174.,  181.,  182.,  185.,  186.,  296.,  297.,  301.,  302.,
      309.,  310.,  313.,  314.,  408.,  409.,  413.,  414.,  421.,  422.,
      425.,  426.,  472.,  473.,  477.,  478.,  485.,  486.,  489.,  490.,
      680.,  681.,  685.,  686.,  693.,  694.,  697.,  698.,  744.,  745.,
      749.,  750.,  757.,  758.,  761.,  762.,  872.,  873.,  877.,  878.,
      885.,  886.,  889.,  890.,  984.,  985.,  989.,  990.,  997.,  998.,
      1001., 1002., 1048., 1049., 1053., 1054., 1061., 1062., 1065., 1066.,
      1256., 1257., 1261., 1262., 1269., 1270., 1273., 1274., 1320., 1321.,
      1325., 1326., 1333., 1334., 1337., 1338., 1448., 1449., 1453., 1454.,
      1461., 1462., 1465., 1466., 1560., 1561., 1565., 1566., 1573., 1574.,
      1577., 1578., 1624., 1625., 1629., 1630., 1637., 1638., 1641., 1642.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x16x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      171.,  172.,  179.,  180.,  299.,  300.,  307.,  308.,
      747.,  748.,  755.,  756.,  875.,  876.,  883.,  884.,
      1323., 1324., 1331., 1332., 1451., 1452., 1459., 1460.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {207.,
                                         208.,
                                         209.,
                                         210.,
                                         217.,
                                         218.,
                                         219.,
                                         220.,
                                         233.,
                                         234.,
                                         235.,
                                         236.,
                                         241.,
                                         242.,
                                         243.,
                                         244.,
                                         335.,
                                         336.,
                                         337.,
                                         338.,
                                         345.,
                                         346.,
                                         347.,
                                         348.,
                                         361.,
                                         362.,
                                         363.,
                                         364.,
                                         369.,
                                         370.,
                                         371.,
                                         372.,
                                         591.,
                                         592.,
                                         593.,
                                         594.,
                                         601.,
                                         602.,
                                         603.,
                                         604.,
                                         617.,
                                         618.,
                                         619.,
                                         620.,
                                         625.,
                                         626.,
                                         627.,
                                         628.,
                                         815.,
                                         816.,
                                         817.,
                                         818.,
                                         825.,
                                         826.,
                                         827.,
                                         828.,
                                         841.,
                                         842.,
                                         843.,
                                         844.,
                                         849.,
                                         850.,
                                         851.,
                                         852.,
                                         943.,
                                         944.,
                                         945.,
                                         946.,
                                         953.,
                                         954.,
                                         955.,
                                         956.,
                                         969.,
                                         970.,
                                         971.,
                                         972.,
                                         977.,
                                         978.,
                                         979.,
                                         980.,
                                         1359.,
                                         1360.,
                                         1361.,
                                         1362.,
                                         1369.,
                                         1370.,
                                         1371.,
                                         1372.,
                                         1385.,
                                         1386.,
                                         1387.,
                                         1388.,
                                         1393.,
                                         1394.,
                                         1395.,
                                         1396.,
                                         1487.,
                                         1488.,
                                         1489.,
                                         1490.,
                                         1497.,
                                         1498.,
                                         1499.,
                                         1500.,
                                         1513.,
                                         1514.,
                                         1515.,
                                         1516.,
                                         1521.,
                                         1522.,
                                         1523.,
                                         1524.,
                                         1556.8181818181818,
                                         1557.8181818181818,
                                         1558.8181818181818,
                                         1559.8181818181818,
                                         1566.8181818181818,
                                         1567.8181818181818,
                                         1568.8181818181818,
                                         1569.8181818181818,
                                         1582.8181818181818,
                                         1583.8181818181818,
                                         1584.8181818181818,
                                         1585.8181818181818,
                                         1590.8181818181818,
                                         1591.8181818181818,
                                         1592.8181818181818,
                                         1593.8181818181818,
                                         1147.8,
                                         1148.8,
                                         1149.8,
                                         1150.8,
                                         1157.8,
                                         1158.8,
                                         1159.8,
                                         1160.8,
                                         1173.8,
                                         1174.8,
                                         1175.8,
                                         1176.8,
                                         1181.8,
                                         1182.8,
                                         1183.8,
                                         1184.8,
                                         729.6666666666666,
                                         730.6666666666666,
                                         731.6666666666666,
                                         732.6666666666666,
                                         739.6666666666666,
                                         740.6666666666666,
                                         741.6666666666666,
                                         742.6666666666666,
                                         755.6666666666666,
                                         756.6666666666666,
                                         757.6666666666666,
                                         758.6666666666666,
                                         763.6666666666666,
                                         764.6666666666666,
                                         765.6666666666666,
                                         766.6666666666666,
                                         463.,
                                         464.,
                                         465.,
                                         466.,
                                         473.,
                                         474.,
                                         475.,
                                         476.,
                                         489.,
                                         490.,
                                         491.,
                                         492.,
                                         497.,
                                         498.,
                                         499.,
                                         500.,
                                         591.,
                                         592.,
                                         593.,
                                         594.,
                                         601.,
                                         602.,
                                         603.,
                                         604.,
                                         617.,
                                         618.,
                                         619.,
                                         620.,
                                         625.,
                                         626.,
                                         627.,
                                         628.,
                                         847.,
                                         848.,
                                         849.,
                                         850.,
                                         857.,
                                         858.,
                                         859.,
                                         860.,
                                         873.,
                                         874.,
                                         875.,
                                         876.,
                                         881.,
                                         882.,
                                         883.,
                                         884.,
                                         1071.,
                                         1072.,
                                         1073.,
                                         1074.,
                                         1081.,
                                         1082.,
                                         1083.,
                                         1084.,
                                         1097.,
                                         1098.,
                                         1099.,
                                         1100.,
                                         1105.,
                                         1106.,
                                         1107.,
                                         1108.,
                                         1199.,
                                         1200.,
                                         1201.,
                                         1202.,
                                         1209.,
                                         1210.,
                                         1211.,
                                         1212.,
                                         1225.,
                                         1226.,
                                         1227.,
                                         1228.,
                                         1233.,
                                         1234.,
                                         1235.,
                                         1236.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x16x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {341.,
                                         342.,
                                         343.,
                                         344.,
                                         357.,
                                         358.,
                                         359.,
                                         360.,
                                         597.,
                                         598.,
                                         599.,
                                         600.,
                                         613.,
                                         614.,
                                         615.,
                                         616.,
                                         1493.,
                                         1494.,
                                         1495.,
                                         1496.,
                                         1509.,
                                         1510.,
                                         1511.,
                                         1512.,
                                         1562.8181818181818,
                                         1563.8181818181818,
                                         1564.8181818181818,
                                         1565.8181818181818,
                                         1578.8181818181818,
                                         1579.8181818181818,
                                         1580.8181818181818,
                                         1581.8181818181818,
                                         597.,
                                         598.,
                                         599.,
                                         600.,
                                         613.,
                                         614.,
                                         615.,
                                         616.,
                                         853.,
                                         854.,
                                         855.,
                                         856.,
                                         869.,
                                         870.,
                                         871.,
                                         872.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58.,  60.,  64.,  67.5,  69.5,  94.,  96.,  100., 103.5, 105.5,
      166., 168., 172., 175.5, 177.5, 229., 231., 235., 238.5, 240.5,
      265., 267., 271., 274.5, 276.5, 382., 384., 388., 391.5, 393.5,
      418., 420., 424., 427.5, 429.5, 490., 492., 496., 499.5, 501.5,
      553., 555., 559., 562.5, 564.5, 589., 591., 595., 598.5, 600.5,
      706., 708., 712., 715.5, 717.5, 742., 744., 748., 751.5, 753.5,
      814., 816., 820., 823.5, 825.5, 877., 879., 883., 886.5, 888.5,
      913., 915., 919., 922.5, 924.5};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x18x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {96.,  100., 168., 172., 420., 424.,
                                         492., 496., 744., 748., 816., 820.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115.,  116.,  119.,  120.,  127.,  128.,  134.,  135.,  138.,  139.,
      187.,  188.,  191.,  192.,  199.,  200.,  206.,  207.,  210.,  211.,
      331.,  332.,  335.,  336.,  343.,  344.,  350.,  351.,  354.,  355.,
      457.,  458.,  461.,  462.,  469.,  470.,  476.,  477.,  480.,  481.,
      529.,  530.,  533.,  534.,  541.,  542.,  548.,  549.,  552.,  553.,
      763.,  764.,  767.,  768.,  775.,  776.,  782.,  783.,  786.,  787.,
      835.,  836.,  839.,  840.,  847.,  848.,  854.,  855.,  858.,  859.,
      979.,  980.,  983.,  984.,  991.,  992.,  998.,  999.,  1002., 1003.,
      1105., 1106., 1109., 1110., 1117., 1118., 1124., 1125., 1128., 1129.,
      1177., 1178., 1181., 1182., 1189., 1190., 1196., 1197., 1200., 1201.,
      1411., 1412., 1415., 1416., 1423., 1424., 1430., 1431., 1434., 1435.,
      1483., 1484., 1487., 1488., 1495., 1496., 1502., 1503., 1506., 1507.,
      1627., 1628., 1631., 1632., 1639., 1640., 1646., 1647., 1650., 1651.,
      1753., 1754., 1757., 1758., 1765., 1766., 1772., 1773., 1776., 1777.,
      1825., 1826., 1829., 1830., 1837., 1838., 1844., 1845., 1848., 1849.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x18x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      191.,  192.,  199.,  200.,  335.,  336.,  343.,  344.,
      839.,  840.,  847.,  848.,  983.,  984.,  991.,  992.,
      1487., 1488., 1495., 1496., 1631., 1632., 1639., 1640.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, SAME3x18x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {229.,
                                         230.,
                                         231.,
                                         232.,
                                         237.,
                                         238.,
                                         239.,
                                         240.,
                                         253.,
                                         254.,
                                         255.,
                                         256.,
                                         267.,
                                         268.,
                                         269.,
                                         270.,
                                         275.,
                                         276.,
                                         277.,
                                         278.,
                                         373.,
                                         374.,
                                         375.,
                                         376.,
                                         381.,
                                         382.,
                                         383.,
                                         384.,
                                         397.,
                                         398.,
                                         399.,
                                         400.,
                                         411.,
                                         412.,
                                         413.,
                                         414.,
                                         419.,
                                         420.,
                                         421.,
                                         422.,
                                         661.,
                                         662.,
                                         663.,
                                         664.,
                                         669.,
                                         670.,
                                         671.,
                                         672.,
                                         685.,
                                         686.,
                                         687.,
                                         688.,
                                         699.,
                                         700.,
                                         701.,
                                         702.,
                                         707.,
                                         708.,
                                         709.,
                                         710.,
                                         913.,
                                         914.,
                                         915.,
                                         916.,
                                         921.,
                                         922.,
                                         923.,
                                         924.,
                                         937.,
                                         938.,
                                         939.,
                                         940.,
                                         951.,
                                         952.,
                                         953.,
                                         954.,
                                         959.,
                                         960.,
                                         961.,
                                         962.,
                                         1057.,
                                         1058.,
                                         1059.,
                                         1060.,
                                         1065.,
                                         1066.,
                                         1067.,
                                         1068.,
                                         1081.,
                                         1082.,
                                         1083.,
                                         1084.,
                                         1095.,
                                         1096.,
                                         1097.,
                                         1098.,
                                         1103.,
                                         1104.,
                                         1105.,
                                         1106.,
                                         1525.,
                                         1526.,
                                         1527.,
                                         1528.,
                                         1533.,
                                         1534.,
                                         1535.,
                                         1536.,
                                         1549.,
                                         1550.,
                                         1551.,
                                         1552.,
                                         1563.,
                                         1564.,
                                         1565.,
                                         1566.,
                                         1571.,
                                         1572.,
                                         1573.,
                                         1574.,
                                         1669.,
                                         1670.,
                                         1671.,
                                         1672.,
                                         1626.2231404958677,
                                         1627.2231404958677,
                                         1628.2231404958677,
                                         1629.2231404958677,
                                         1574.5206611570247,
                                         1575.5206611570247,
                                         1576.5206611570247,
                                         1577.5206611570247,
                                         1520.8181818181818,
                                         1521.8181818181818,
                                         1522.8181818181818,
                                         1523.8181818181818,
                                         1528.8181818181818,
                                         1529.8181818181818,
                                         1530.8181818181818,
                                         1531.8181818181818,
                                         1212.2727272727273,
                                         1213.2727272727273,
                                         1214.2727272727273,
                                         1215.2727272727273,
                                         1169.495867768595,
                                         1170.495867768595,
                                         1171.495867768595,
                                         1172.495867768595,
                                         1117.793388429752,
                                         1118.793388429752,
                                         1119.793388429752,
                                         1120.793388429752,
                                         1064.090909090909,
                                         1065.090909090909,
                                         1066.090909090909,
                                         1067.090909090909,
                                         1072.090909090909,
                                         1073.090909090909,
                                         1074.090909090909,
                                         1075.090909090909,
                                         775.4,
                                         776.4,
                                         777.4,
                                         778.4,
                                         727.5454545454545,
                                         728.5454545454545,
                                         729.5454545454545,
                                         730.5454545454545,
                                         669.0727272727273,
                                         670.0727272727273,
                                         671.0727272727273,
                                         672.0727272727273,
                                         608.6,
                                         609.6,
                                         610.6,
                                         611.6,
                                         616.6,
                                         617.6,
                                         618.6,
                                         619.6,
                                         305.,
                                         306.,
                                         307.,
                                         308.,
                                         313.,
                                         314.,
                                         315.,
                                         316.,
                                         329.,
                                         330.,
                                         331.,
                                         332.,
                                         343.,
                                         344.,
                                         345.,
                                         346.,
                                         351.,
                                         352.,
                                         353.,
                                         354.,
                                         773.,
                                         774.,
                                         775.,
                                         776.,
                                         781.,
                                         782.,
                                         783.,
                                         784.,
                                         797.,
                                         798.,
                                         799.,
                                         800.,
                                         811.,
                                         812.,
                                         813.,
                                         814.,
                                         819.,
                                         820.,
                                         821.,
                                         822.,
                                         917.,
                                         918.,
                                         919.,
                                         920.,
                                         925.,
                                         926.,
                                         927.,
                                         928.,
                                         941.,
                                         942.,
                                         943.,
                                         944.,
                                         955.,
                                         956.,
                                         957.,
                                         958.,
                                         963.,
                                         964.,
                                         965.,
                                         966.,
                                         1205.,
                                         1206.,
                                         1207.,
                                         1208.,
                                         1213.,
                                         1214.,
                                         1215.,
                                         1216.,
                                         1229.,
                                         1230.,
                                         1231.,
                                         1232.,
                                         1243.,
                                         1244.,
                                         1245.,
                                         1246.,
                                         1251.,
                                         1252.,
                                         1253.,
                                         1254.,
                                         1457.,
                                         1458.,
                                         1459.,
                                         1460.,
                                         1465.,
                                         1466.,
                                         1467.,
                                         1468.,
                                         1481.,
                                         1482.,
                                         1483.,
                                         1484.,
                                         1495.,
                                         1496.,
                                         1497.,
                                         1498.,
                                         1503.,
                                         1504.,
                                         1505.,
                                         1506.,
                                         1601.,
                                         1602.,
                                         1603.,
                                         1604.,
                                         1609.,
                                         1610.,
                                         1611.,
                                         1612.,
                                         1625.,
                                         1626.,
                                         1627.,
                                         1628.,
                                         1639.,
                                         1640.,
                                         1641.,
                                         1642.,
                                         1647.,
                                         1648.,
                                         1649.,
                                         1650.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow11Stride4Forward, VALID3x18x18x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {381.,
                                         382.,
                                         383.,
                                         384.,
                                         397.,
                                         398.,
                                         399.,
                                         400.,
                                         669.,
                                         670.,
                                         671.,
                                         672.,
                                         685.,
                                         686.,
                                         687.,
                                         688.,
                                         1626.2231404958677,
                                         1627.2231404958677,
                                         1628.2231404958677,
                                         1629.2231404958677,
                                         1574.5206611570247,
                                         1575.5206611570247,
                                         1576.5206611570247,
                                         1577.5206611570247,
                                         1169.495867768595,
                                         1170.495867768595,
                                         1171.495867768595,
                                         1172.495867768595,
                                         1117.793388429752,
                                         1118.793388429752,
                                         1119.793388429752,
                                         1120.793388429752,
                                         925.,
                                         926.,
                                         927.,
                                         928.,
                                         941.,
                                         942.,
                                         943.,
                                         944.,
                                         1213.,
                                         1214.,
                                         1215.,
                                         1216.,
                                         1229.,
                                         1230.,
                                         1231.,
                                         1232.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<11, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
